//package org.example.springmybatisdemo.utils;
//
//import cn.ucloud.ufile.UfileClient;
//import cn.ucloud.ufile.bean.BucketResponse;
//import cn.ucloud.ufile.bean.PutObjectResultBean;
//import cn.ucloud.ufile.config.ObjectConfig;
//import cn.ucloud.ufile.config.UfileClientConfig;
//import cn.ucloud.ufile.exception.UfileClientException;
//import cn.ucloud.ufile.exception.UfileServerException;
//import cn.ucloud.ufile.http.HttpClientConfig;
//import cn.ucloud.ufile.model.BucketAuthorization;
//import cn.ucloud.ufile.model.ObjectAuthorization;
//import cn.ucloud.ufile.model.ObjectRemoteAuthorization;
//import cn.ucloud.ufile.operation.BucketOperation;
//import cn.ucloud.ufile.operation.ObjectOperation;
//import okhttp3.Interceptor;
//import java.io.File;
//import java.util.concurrent.ExecutorService;
//import java.util.concurrent.TimeUnit;
//
///**
// * Ufile 工具类（封装初始化、Bucket操作、文件上传等功能）
// */
//public class UfileUtils {
//
//    // 单例实例
//    private static volatile UfileUtils instance;
//
//    // Bucket 操作对象（需授权器和配置）
//    private BucketOperation bucketOperation;
//
//    // 对象（文件）操作对象（需授权器、ObjectConfig）
//    private ObjectOperation objectOperation;
//
//    // 私有构造函数（防止外部实例化）
//    private UfileUtils(Builder builder) {
//        // 初始化 UfileClient 全局配置（必须在首次调用前完成）
//        initUfileClient(builder.httpClientConfig);
//
//        // 初始化 Bucket 操作（本地授权）
//        BucketAuthorization bucketAuth = new UfileBucketLocalAuthorization(
//                builder.publicKey, builder.privateKey);
//        this.bucketOperation = UfileClient.bucket(bucketAuth);
//
//        // 初始化对象操作（本地授权 + ObjectConfig）
//        ObjectAuthorization objectAuth = new UfileObjectLocalAuthorization(
//                builder.publicKey, builder.privateKey);
//        this.objectOperation = UfileClient.object(objectAuth, builder.objectConfig);
//    }
//
//    /**
//     * 获取单例实例（Builder 模式配置参数）
//     */
//    public static UfileUtils getInstance(Builder builder) {
//        if (instance == null) {
//            synchronized (UfileUtils.class) {
//                if (instance == null) {
//                    instance = new UfileUtils(builder);
//                }
//            }
//        }
//        return instance;
//    }
//
//    /**
//     * 初始化 UfileClient 全局配置（必须在首次调用前执行）
//     */
//    private void initUfileClient(HttpClientConfig httpClientConfig) {
//        UfileClient.configure(new UfileClientConfig.Builder()
//                .httpClientConfig(httpClientConfig)
//                .build());
//    }
//
//    // ---------------------- Bucket 操作 ----------------------
//
//    /**
//     * 同步创建 Bucket
//     * @param bucketName Bucket 名称
//     * @param region 地区编码（如 "cn-bj"）
//     * @param bucketType Bucket 类型（如 "private" 私有读写）
//     * @return BucketResponse 创建结果
//     * @throws UfileClientException 客户端异常
//     * @throws UfileServerException 服务端异常
//     */
//    public BucketResponse createBucketSync(String bucketName, String region, String bucketType)
//            throws UfileClientException, UfileServerException {
//        return bucketOperation.createBucket(bucketName, region, bucketType).execute();
//    }
//
//    /**
//     * 异步创建 Bucket（回调通知结果）
//     * @param bucketName Bucket 名称
//     * @param region 地区编码
//     * @param bucketType Bucket 类型
//     * @param callback 异步回调
//     */
//    public void createBucketAsync(String bucketName, String region, String bucketType,
//                                  UfileCallback<BucketResponse> callback) {
//        bucketOperation.createBucket(bucketName, region, bucketType)
//                .executeAsync(callback);
//    }
//
//    // ---------------------- 文件上传操作 ----------------------
//
//    /**
//     * 同步上传文件（默认校验 MD5、每秒进度回调）
//     * @param localFile 本地文件路径
//     * @param mimeType 文件 MIME 类型（如 "image/jpeg"）
//     * @param keyName 云端存储的文件名（Key）
//     * @param bucketName 目标 Bucket 名称
//     * @return PutObjectResultBean 上传结果
//     * @throws UfileClientException 客户端异常
//     * @throws UfileServerException 服务端异常
//     */
//    public PutObjectResultBean uploadFileSync(String localFile, String mimeType,
//                                              String keyName, String bucketName)
//            throws UfileClientException, UfileServerException {
//        return uploadFile(localFile, mimeType, keyName, bucketName, true, null, null);
//    }
//
//    /**
//     * 异步上传文件（默认校验 MD5、每秒进度回调）
//     * @param localFile 本地文件路径
//     * @param mimeType 文件 MIME 类型
//     * @param keyName 云端存储的文件名
//     * @param bucketName 目标 Bucket 名称
//     * @param callback 上传进度与结果回调
//     */
//    public void uploadFileAsync(String localFile, String mimeType, String keyName,
//                                String bucketName, UfileCallback<PutObjectResultBean> callback) {
//        uploadFile(localFile, mimeType, keyName, bucketName, true, null, callback);
//    }
//
//    /**
//     * 自定义配置上传文件（支持 MD5 校验、进度监听等）
//     * @param localFile 本地文件路径
//     * @param mimeType 文件 MIME 类型
//     * @param keyName 云端存储的文件名
//     * @param bucketName 目标 Bucket 名称
//     * @param verifyMd5 是否校验 MD5（默认 true）
//     * @param progressConfig 进度回调配置（如每 10% 回调一次）
//     * @param callback 上传结果回调（可选，若传 null 则使用进度监听）
//     * @return 同步上传结果（若 callback 为 null 时返回）
//     */
//    public PutObjectResultBean uploadFile(String localFile, String mimeType, String keyName,
//                                          String bucketName, boolean verifyMd5,
//                                          ProgressConfig progressConfig,
//                                          UfileCallback<PutObjectResultBean> callback) {
//        try {
//            // 构建上传链式调用
//            PutObjectResultBean result = objectOperation.putObject(new File(localFile), mimeType)
//                    .nameAs(keyName)
//                    .toBucket(bucketName)
//                    .withVerifyMd5(verifyMd5);
//
//            // 配置进度监听（可选）
//            if (progressConfig != null) {
//                result = result.withProgressConfig(progressConfig);
//            }
//
//            // 执行同步或异步
//            if (callback == null) {
//                return result.execute();
//            } else {
//                result.executeAsync(callback);
//                return null; // 异步无返回值
//            }
//        } catch (UfileClientException | UfileServerException e) {
//            if (callback != null) {
//                // 异步模式下异常通过 callback 传递，此处无需处理
//            } else {
//                throw e; // 同步模式抛出异常
//            }
//        }
//        return null;
//    }
//
//    // ---------------------- 配置类 ----------------------
//
//    /**
//     * Builder 模式（用于配置 UfileClient 参数）
//     */
//    public static class Builder {
//        // 必选参数
//        private String publicKey;     // 公钥
//        private String privateKey;    // 私钥
//        private String region;        // Bucket 地区编码（如 "cn-bj"）
//
//        // 可选参数（带默认值）
//        private HttpClientConfig httpClientConfig;  // HTTP 客户端配置（默认：合理超时+线程池）
//        private ObjectConfig objectConfig;          // 对象存储配置（默认：使用地区编码）
//        private ExecutorService executorService;    // 线程池（默认：Ufile 内部线程池）
//
//        /**
//         * 构造 Builder（必选参数）
//         */
//        public Builder(String publicKey, String privateKey, String region) {
//            this.publicKey = publicKey;
//            this.privateKey = privateKey;
//            this.region = region;
//        }
//
//        /**
//         * 配置 HTTP 客户端（超时、线程池、拦截器等）
//         */
//        public Builder httpClientConfig(HttpClientConfig config) {
//            this.httpClientConfig = config;
//            return this;
//        }
//
//        /**
//         * 配置 ObjectConfig（自定义域名、地区等）
//         */
//        public Builder objectConfig(ObjectConfig config) {
//            this.objectConfig = config;
//            return this;
//        }
//
//        /**
//         * 配置自定义线程池（默认使用 Ufile 内部线程池）
//         */
//        public Builder executorService(ExecutorService executor) {
//            this.executorService = executor;
//            return this;
//        }
//
//        /**
//         * 构建 UfileUtils 实例
//         */
//        public UfileUtils build() {
//            // 校验必选参数
//            if (publicKey == null || privateKey == null || region == null) {
//                throw new IllegalArgumentException("公钥、私钥、地区编码为必选参数");
//            }
//
//            // 设置默认 HTTP 配置（若未传入）
//            if (httpClientConfig == null) {
//                httpClientConfig = new HttpClientConfig.Builder()
//                        .setTimeout(30_000, 30_000, 30_000) // 连接/读取/写入超时 30s
//                        .setExecutorService(executorService != null ?
//                                executorService : Executors.newCachedThreadPool())
//                        .build();
//            }
//
//            // 设置默认 ObjectConfig（若未传入）
//            if (objectConfig == null) {
//                objectConfig = new ObjectConfig(region, "ufileos.com"); // 默认使用官方域名
//            }
//
//            return new UfileUtils(this);
//        }
//    }
//
//    // ---------------------- 进度配置类 ----------------------
//    /**
//     * 进度回调配置（简化版，支持自定义回调间隔）
//     */
//    public static class ProgressConfig {
//        private long callbackIntervalBytes;  // 每隔多少字节回调一次
//        private OnProgressListener listener; // 进度监听器
//
//        private ProgressConfig(Builder builder) {
//            this.callbackIntervalBytes = builder.interval;
//            this.listener = builder.listener;
//        }
//
//        /**
//         * 每秒回调（默认 1000ms）
//         */
//        public static ProgressConfig callbackPerSecond() {
//            return new ProgressConfig.Builder(1024 * 1024) // 1MB 回调一次（约每秒）
//                    .listener((bytesWritten, contentLength) -> {
//                        double percent = (contentLength > 0) ?
//                                (bytesWritten * 100.0 / contentLength) : 0;
//                        System.out.printf("上传进度：%.2f%%\n", percent);
//                    }).build();
//        }
//
//        /**
//         * 自定义间隔回调
//         */
//        public static ProgressConfig callbackWithInterval(long intervalBytes, OnProgressListener listener) {
//            return new ProgressConfig.Builder(intervalBytes)
//                    .listener(listener)
//                    .build();
//        }
//
//        // 进度监听接口
//        public interface OnProgressListener {
//            void onProgress(long bytesWritten, long contentLength);
//        }
//
//        // Builder 模式（内部类）
//        public static class Builder {
//            private long interval;       // 回调间隔（字节）
//            private OnProgressListener listener;
//
//            public Builder(long interval) {
//                this.interval = interval;
//            }
//
//            public Builder listener(OnProgressListener listener) {
//                this.listener = listener;
//                return this;
//            }
//
//            public ProgressConfig build() {
//                return new ProgressConfig(this);
//            }
//        }
//    }
//
//    // ---------------------- 回调接口 ----------------------
//    /**
//     * Ufile 异步回调接口（简化版）
//     * @param <T> 响应数据类型
//     */
//    public interface UfileCallback<T> {
//        /**
//         * 上传/下载进度回调（可选）
//         */
//        default void onProgress(long bytesWritten, long contentLength) {}
//
//        /**
//         * 成功回调
//         */
//        void onResponse(T response);
//
//        /**
//         * 失败回调
//         */
//        void onError(Request request, ApiError error, UfileErrorBean response);
//    }
//}
